const fs = require("fs");
const path = require("path");
const { loadConfig } = require("./utils/config");
const { parseSRT } = require("./utils/subtitle");
const { parseASS } = require("./utils/assParser");
const { extractKeywords } = require("./utils/keywordExtractor");
const { findImageInStore, saveImageToStore } = require("./utils/mediaStore");
const { downloadImageFromPexels } = require("./utils/pexelsDownloader");
const { downloadVideoFromPexels } = require("./utils/pexelsVideoDownloader");

// 读取配置文件
const config = loadConfig();

// 确保配置项存在，如果不存在则使用默认值
const outputDirSrt = config.outputDirSrt || "./temp/srt";
const inputDirImages = config.inputDirImages || "./temp/imgs";
const inputDirVideos = config.inputDirVideos || "./input/videos";
/**
 * 解析字幕文件（支持ASS和SRT格式）
 * @param {string} subtitlePath - 字幕文件路径
 * @returns {Array} 字幕条目数组
 */
function parseSubtitle(subtitlePath) {
  // 检查文件扩展名
  const ext = path.extname(subtitlePath).toLowerCase();

  if (ext === ".ass") {
    return parseASS(subtitlePath);
  } else {
    return parseSRT(subtitlePath);
  }
}

/**
 * 为主要关键词下载媒体文件（优先视频，备选图片）
 * @param {string} subtitleFile - 字幕文件路径
 * @param {string} imgsDir - 图片输出目录
 * @param {number} maxImages - 最大媒体文件数量
 */
async function downloadImagesForSrt(subtitleFile, imgsDir, maxImages = 10) {
  // 使用通用字幕解析函数
  const subtitles = parseSubtitle(subtitleFile);
  console.log(`  解析到 ${subtitles.length} 条字幕`);

  // 确保图片目录存在
  if (!fs.existsSync(imgsDir)) {
    fs.mkdirSync(imgsDir, { recursive: true });
  }

  // 提取关键词
  const keywordsList = subtitles.map((sub, index) => ({
    index: index + 1, // 对于ASS文件，我们需要手动分配索引
    text: sub.text,
    // 最多提取三个关键字
    keywords: extractKeywords(sub.text, 3),
  }));

  // console.log(`提取的关键词（前5个）:`, keywordsList.slice(0, 5)); // 只显示前5个

  // 存储已下载的关键词和对应的图片路径
  const downloadedKeywords = {};

  // 为每个关键词下载媒体文件
  let downloadedCount = 0;

  // 按关键词排序以确保处理顺序一致
  const sortedKeywordsList = [...keywordsList].sort((a, b) => a.keywords.localeCompare(b.keywords));
  let index = 0;
  for (const item of sortedKeywordsList) {
    index++;
    console.log(`  开始处理${index}/${sortedKeywordsList.length}关键字:${item.keywords}`);
    if (downloadedCount >= maxImages) {
      break;
    }

    const outputPath = path.join(imgsDir, `img_${item.index.toString().padStart(3, "0")}.jpg`);

    // 检查是否存在inputDirVideos目录且不为空，则随机使用其中的文件
    if (fs.existsSync(inputDirVideos)) {
      console.log(`  使用inputDirVideos中的视频文件`);
      const videoFiles = fs.readdirSync(inputDirVideos).filter(file => {
        const ext = path.extname(file).toLowerCase();
        return ext === '.mp4' || ext === '.avi' || ext === '.mov' || ext === '.mkv';
      });
      
      if (videoFiles.length > 0) {
        // 随机选择一个视频文件
        const randomVideo = videoFiles[Math.floor(Math.random() * videoFiles.length)];
        const sourcePath = path.join(inputDirVideos, randomVideo);
        const destPath = path.join(imgsDir, `img_${item.index.toString().padStart(3, "0")}${path.extname(randomVideo)}`);
        
        fs.copyFileSync(sourcePath, destPath);
        console.log(`    使用inputDirVideos中的视频文件: ${randomVideo}`);
        downloadedCount++;
        continue; // 跳过字幕匹配
      }
    }
    // 检查图片是否已存在
    if (fs.existsSync(outputPath)) {
      console.log(`媒体文件已存在，跳过: ${outputPath}`);
      downloadedCount++;
      continue;
    }

    // 检查媒体仓库中是否有相关媒体文件（视频优先，图片备选）
    const storedMedia = findImageInStore(item.keywords);
    if (storedMedia) {
      // 使用仓库中的媒体文件
      const storedMediaExt = path.extname(storedMedia).toLowerCase();
      const outputPathWithCorrectExt = path.join(imgsDir, `img_${item.index.toString().padStart(3, "0")}${storedMediaExt}`);

      fs.copyFileSync(storedMedia, outputPathWithCorrectExt);
      console.log(`    使用仓库中的媒体文件: ${storedMedia} -> ${outputPathWithCorrectExt}`);
      downloadedCount++;
      continue;
    }

    // 优先尝试下载视频
    const videoPath = path.join(imgsDir, `video_${item.index}.mp4`);
    let success = await downloadVideoFromPexels(item.keywords, videoPath);
    if (success) {
      // 保存视频到仓库
      saveImageToStore(videoPath, item.keywords);
      // 复制到标准输出路径，保持正确的扩展名
      const finalVideoPath = path.join(imgsDir, `img_${item.index.toString().padStart(3, "0")}.mp4`);
      fs.copyFileSync(videoPath, finalVideoPath);
      downloadedKeywords[item.keywords] = finalVideoPath;
      downloadedCount++;
    } else {
      // 如果视频下载失败，下载图片作为备选
      const imagePath = path.join(imgsDir, `img_${item.index.toString().padStart(3, "0")}.jpg`);
      success = await downloadImageFromPexels(item.keywords, imagePath);
      if (success) {
        // 保存图片到仓库
        saveImageToStore(imagePath, item.keywords);
        downloadedKeywords[item.keywords] = imagePath;
        downloadedCount++;
      }
    }

    // 添加延迟以避免API限制
    await new Promise(resolve => setTimeout(resolve, 1000));
  }

  console.log(`  总共处理了 ${downloadedCount} 个媒体文件`);
  console.log(`  本次下载的唯一关键词媒体文件数量: ${Object.keys(downloadedKeywords).length}`);
}

// 主函数
async function main() {
  const args = process.argv.slice(2);

  if (args.length < 1) {
    console.log("使用方法: node download_images.js <字幕文件编号> [最大图片数]");
    console.log("示例: node download_images.js 1 10");
    process.exit(1);
  }

  const subtitleNumber = args[0];
  const maxImages = args[1] ? parseInt(args[1]) : 10;

  // 构建ASS文件路径作为首选
  let subtitleFile = path.join(__dirname, `../${outputDirSrt}`, `${subtitleNumber}.ass`);

  // 如果ASS文件不存在，则尝试SRT文件
  if (!fs.existsSync(subtitleFile)) {
    subtitleFile = path.join(__dirname, `../${outputDirSrt}`, `${subtitleNumber}.srt`);

    // 检查SRT文件是否存在
    if (!fs.existsSync(subtitleFile)) {
      console.error(`！！！字幕文件不存在: ${subtitleFile}`);
      process.exit(1);
    }
  }

  const imgsDir = path.join(__dirname, `../${inputDirImages}`);

  // 确保图片目录存在
  if (!fs.existsSync(imgsDir)) {
    fs.mkdirSync(imgsDir, { recursive: true });
  }

  await downloadImagesForSrt(subtitleFile, imgsDir, maxImages);
}

// 如果直接运行此脚本，则执行主函数
if (require.main === module) {
  main();
}

module.exports = {
  downloadImagesForSrt,
};
